require('dotenv').config();
const express = require('express');
const qiniu = require('qiniu');
const https = require('https');
const crypto = require('crypto');
const app = express();
const port = 3000;

// 从环境变量读取配置
const accessKey = process.env.QINIU_ACCESS_KEY;
const secretKey = process.env.QINIU_SECRET_KEY;
const zone = process.env.QINIU_ZONE || 'z0'; // 默认为华东 z0

if (!accessKey || !secretKey) {
    console.error('错误：请确保 .env 文件中已配置 QINIU_ACCESS_KEY 和 QINIU_SECRET_KEY');
    process.exit(1);
}

// 配置七牛云
qiniu.conf.ACCESS_KEY = accessKey;
qiniu.conf.SECRET_KEY = secretKey;
const mac = new qiniu.auth.digest.Mac();
const config = new qiniu.conf.Config();

// 配置存储区域
const zoneMap = {
    'z0': qiniu.zone.Zone_z0,
    'z1': qiniu.zone.Zone_z1,
    'z2': qiniu.zone.Zone_z2,
    'na0': qiniu.zone.Zone_na0,
    'as0': qiniu.zone.Zone_as0,
};

if (zoneMap[zone]) {
    config.zone = zoneMap[zone];
} else {
    console.warn(`警告: 无效的 QINIU_ZONE 配置 "${zone}"。将使用默认区域(华东)。`);
    config.zone = zoneMap['z0'];
}

const bucketManager = new qiniu.rs.BucketManager(mac, config);

// 中间件
app.use(express.static('public'));
app.use(express.json());

// 获取bucket列表
app.get('/api/buckets', (req, res) => {
    bucketManager.listBucket({}, (err, respBody, respInfo) => {
        if (err) {
            console.error('获取bucket列表失败:', err);
            return res.status(500).json({ error: '获取bucket列表失败', details: err.message });
        }
        
        if (respInfo.statusCode !== 200) {
            console.log('API请求失败，状态码:', respInfo.statusCode);
            return res.status(respInfo.statusCode).json(respBody);
        }
        
        res.json({ buckets: respBody });
    });
});

// 获取文件列表
app.get('/api/files', (req, res) => {
    const bucket = req.query.bucket;
    const prefix = req.query.prefix || '';
    const limit = parseInt(req.query.limit) || 1000; // 增大默认限制
    const getAllFiles = req.query.all === 'true'; // 是否获取全部文件
    
    if (!bucket) {
        return res.status(400).json({ error: '缺少 bucket 参数' });
    }
    
    if (getAllFiles) {
        // 递归获取所有文件
        getAllFilesFromBucket(bucket, prefix, (err, allFiles) => {
            if (err) {
                console.error('获取所有文件失败:', err);
                return res.status(500).json({ error: '获取所有文件失败' });
            }
            res.json({ items: allFiles, marker: '' });
        });
    } else {
        // 获取单页文件
        bucketManager.listPrefix(bucket, { prefix, limit }, (err, respBody, respInfo) => {
            if (err) {
                console.error('获取文件列表失败:', err);
                return res.status(500).json({ error: '获取文件列表失败' });
            }
            
            if (respInfo.statusCode === 200) {
                res.json(respBody);
            } else {
                console.error('获取文件列表失败，状态码:', respInfo.statusCode);
                res.status(respInfo.statusCode).json({ error: '获取文件列表失败' });
            }
        });
    }
});

// 递归获取所有文件
function getAllFilesFromBucket(bucket, prefix, callback) {
    let allFiles = [];
    let marker = null;
    
    function listFiles() {
        const options = {
            prefix: prefix,
            limit: 1000 // 每次请求最大数量
        };
        
        if (marker) {
            options.marker = marker;
        }
        
        bucketManager.listPrefix(bucket, options, (err, respBody, respInfo) => {
            if (err) {
                return callback(err);
            }
            
            if (respInfo.statusCode !== 200) {
                return callback(new Error(`获取文件列表失败，状态码: ${respInfo.statusCode}`));
            }
            
            // 添加当前页的文件
            if (respBody.items && respBody.items.length > 0) {
                allFiles = allFiles.concat(respBody.items);
            }
            
            // 检查是否有下一页
            if (respBody.marker) {
                marker = respBody.marker;
                // 继续获取下一页
                listFiles();
            } else {
                // 所有文件已获取完成
                callback(null, allFiles);
            }
        });
    }
    
    // 开始获取文件
    listFiles();
}

// 删除单个文件
app.delete('/api/files', (req, res) => {
    const { bucket, key } = req.body;
    
    if (!bucket || !key) {
        return res.status(400).json({ error: '缺少 bucket 或 key 参数' });
    }
    
    bucketManager.delete(bucket, key, (err, respBody, respInfo) => {
        if (err) {
            console.error('删除文件失败:', err);
            return res.status(500).json({ error: '删除文件失败' });
        }
        
        if (respInfo.statusCode === 200) {
            res.json({ success: true, message: '文件删除成功' });
        } else {
            console.error('删除文件失败，状态码:', respInfo.statusCode);
            res.status(respInfo.statusCode).json({ error: '删除文件失败' });
        }
    });
});

// 批量删除文件
app.delete('/api/files/batch', (req, res) => {
    const { bucket, keys } = req.body;
    
    if (!bucket || !keys || !Array.isArray(keys)) {
        return res.status(400).json({ error: '缺少 bucket 或 keys 参数，keys 必须是数组' });
    }
    
    // 构建批量删除操作
    const deleteOps = keys.map(key => qiniu.rs.deleteOp(bucket, key));
    
    bucketManager.batch(deleteOps, (err, respBody, respInfo) => {
        if (err) {
            console.error('批量删除文件失败:', err);
            return res.status(500).json({ error: '批量删除文件失败' });
        }
        
        if (respInfo.statusCode === 200) {
            res.json({ success: true, message: '文件批量删除成功', results: respBody });
        } else {
            console.error('批量删除文件失败，状态码:', respInfo.statusCode);
            res.status(respInfo.statusCode).json({ error: '批量删除文件失败' });
        }
    });
});

// 获取bucket域名信息
app.get('/api/bucket/domain', (req, res) => {
    const bucket = req.query.bucket;
    console.log('获取域名请求 - bucket:', bucket);
    
    if (!bucket) {
        return res.status(400).json({ error: '缺少 bucket 参数' });
    }

    // 使用SDK的listBucketDomains方法
    bucketManager.listBucketDomains(bucket, (err, respBody, respInfo) => {
        if (err) {
            console.error('获取域名失败:', err);
            return res.status(500).json({ error: '获取域名失败', details: err.message });
        }
        
        console.log('API响应状态码:', respInfo.statusCode);
        console.log('API响应数据:', respBody);
        
        if (respInfo.statusCode === 200) {
            const domains = respBody;
            console.log('解析后的域名列表:', domains);
            
            if (domains && domains.length > 0) {
                // 返回第一个域名
                const domain = domains[0];
                console.log('返回域名:', domain);
                res.json({ 
                    success: true, 
                    domain: domain,
                    allDomains: domains
                });
            } else {
                res.json({ 
                    success: false, 
                    message: '该bucket没有绑定域名' 
                });
            }
        } else {
            console.log('API请求失败，状态码:', respInfo.statusCode);
            res.status(respInfo.statusCode).json({ 
                error: '获取域名失败', 
                details: respBody 
            });
        }
    });
});

app.listen(port, () => {
    console.log(`服务器运行在 http://localhost:${port}`);
});
